import re

# imports
import pytest  # used for our unit tests
from guardrails.utils.tokenization_utils import replace_til_no_change

# unit tests

# ===========================
# Basic Test Cases
# ===========================

def test_basic_no_match():
    """
    No match in the input text; should return the input unchanged.
    """
    codeflash_output = replace_til_no_change("hello world", r"foo", "bar") # 4.10μs -> 4.19μs (2.08% slower)

def test_basic_single_replacement():
    """
    Single occurrence replaced.
    """
    codeflash_output = replace_til_no_change("hello foo world", r"foo", "bar") # 4.60μs -> 4.58μs (0.415% faster)

def test_basic_multiple_replacements():
    """
    Multiple occurrences replaced in one pass.
    """
    codeflash_output = replace_til_no_change("foo foo foo", r"foo", "bar") # 4.54μs -> 4.37μs (3.96% faster)

def test_basic_chained_replacement():
    """
    Replacement causes new matches to appear (e.g., replacing 'aa' with 'a').
    """
    codeflash_output = replace_til_no_change("aaaa", r"aa", "a") # 4.76μs -> 4.23μs (12.6% faster)

def test_basic_overlapping_pattern():
    """
    Overlapping patterns: 'aba' -> 'a' with pattern 'ab'.
    """
    codeflash_output = replace_til_no_change("ababab", r"ab", "a") # 4.46μs -> 3.76μs (18.5% faster)

def test_basic_empty_string():
    """
    Input is empty string.
    """
    codeflash_output = replace_til_no_change("", r".", "x") # 3.37μs -> 3.41μs (1.23% slower)


def test_basic_empty_replacement():
    """
    Replacement is empty string; pattern removed.
    """
    codeflash_output = replace_til_no_change("banana", r"a", "") # 5.33μs -> 5.69μs (6.32% slower)

# ===========================
# Edge Test Cases
# ===========================

def test_edge_pattern_matches_whole_string():
    """
    Pattern matches the entire string.
    """
    codeflash_output = replace_til_no_change("abc", r".*", "x") # 7.45μs -> 6.94μs (7.37% faster)

def test_edge_pattern_matches_nothing():
    """
    Pattern matches nothing (impossible match).
    """
    codeflash_output = replace_til_no_change("abc", r"z+", "x") # 4.42μs -> 4.04μs (9.40% faster)

def test_edge_pattern_is_lookahead():
    """
    Pattern uses lookahead and lookbehind.
    """
    # Insert 'X' before every 'b' that follows an 'a'
    codeflash_output = replace_til_no_change("abcbab", r"(?<=a)b", "X") # 6.00μs -> 5.49μs (9.18% faster)

def test_edge_replacement_creates_new_match():
    """
    Replacement creates new matches for the pattern.
    """
    # Replace 'ab' with 'ba', which then creates new 'ab'
    codeflash_output = replace_til_no_change("abab", r"ab", "ba") # 5.26μs -> 4.46μs (17.9% faster)

def test_edge_replacement_is_same_as_pattern():
    """
    Replacement is the same as the pattern; should terminate immediately.
    """
    codeflash_output = replace_til_no_change("aaaa", r"a", "a") # 3.71μs -> 3.99μs (7.04% slower)

def test_edge_replacement_empty_and_pattern_empty():
    """
    Both pattern and replacement are empty; should not change string.
    """
    codeflash_output = replace_til_no_change("abc", r"", "") # 4.86μs -> 4.70μs (3.32% faster)

def test_edge_unicode_handling():
    """
    Unicode characters in input and pattern.
    """
    codeflash_output = replace_til_no_change("café café", r"é", "e") # 5.04μs -> 4.73μs (6.57% faster)

def test_edge_newline_handling():
    """
    Input contains newlines, pattern matches across lines.
    """
    codeflash_output = replace_til_no_change("foo\nbar", r"\n", " ") # 4.69μs -> 4.04μs (16.0% faster)

def test_edge_non_greedy_pattern():
    """
    Non-greedy pattern replacement.
    """
    codeflash_output = replace_til_no_change("aabbaa", r"a+", "x") # 6.10μs -> 5.25μs (16.1% faster)

def test_edge_long_pattern():
    """
    Very long pattern, longer than input.
    """
    codeflash_output = replace_til_no_change("abc", r"abcdefghijklmnopqrstuvwxyz", "X") # 3.65μs -> 3.75μs (2.62% slower)


def test_edge_pattern_is_dot():
    """
    Pattern is '.', matches any character.
    """
    codeflash_output = replace_til_no_change("abc", r".", "z") # 5.74μs -> 6.14μs (6.55% slower)

def test_edge_pattern_is_digit():
    """
    Pattern matches digits only.
    """
    codeflash_output = replace_til_no_change("a1b2c3", r"\d", "x") # 6.58μs -> 5.77μs (14.0% faster)

def test_edge_pattern_is_whitespace():
    """
    Pattern matches whitespace.
    """
    codeflash_output = replace_til_no_change("a b\tc\nd", r"\s", "_") # 6.08μs -> 6.04μs (0.795% faster)

def test_edge_pattern_with_group():
    """
    Pattern with capturing group.
    """
    codeflash_output = replace_til_no_change("foo123bar456", r"(\d+)", "X") # 6.45μs -> 6.00μs (7.57% faster)


def test_large_scale_many_replacements():
    """
    Large input with many replacements.
    """
    input_text = "a" * 1000
    # Replace 'aa' with 'a' until only one 'a' remains
    codeflash_output = replace_til_no_change(input_text, r"aa", "a") # 27.0μs -> 25.4μs (6.62% faster)

def test_large_scale_no_replacements():
    """
    Large input with no matches.
    """
    input_text = "b" * 1000
    codeflash_output = replace_til_no_change(input_text, r"a", "x") # 4.07μs -> 4.53μs (10.1% slower)

def test_large_scale_pattern_everywhere():
    """
    Replace every character in a large string.
    """
    input_text = "x" * 1000
    codeflash_output = replace_til_no_change(input_text, r".", "y") # 120μs -> 113μs (5.88% faster)

def test_large_scale_chained_replacement():
    """
    Chained replacements in a large string.
    """
    input_text = "ab" * 500  # 1000 characters
    # Replace 'ab' with 'ba', which creates new 'ab'
    # After one pass: 'ba' * 500
    # After another: no 'ab' left, so it should stop
    codeflash_output = replace_til_no_change(input_text, r"ab", "ba") # 2.62ms -> 2.45ms (6.75% faster)

def test_large_scale_pattern_at_boundaries():
    """
    Pattern matches at the start and end of a large string.
    """
    input_text = "a" + "b" * 998 + "a"
    codeflash_output = replace_til_no_change(input_text, r"a", "z") # 6.03μs -> 6.16μs (2.03% slower)

def test_large_scale_pattern_with_newlines():
    """
    Large input with newlines, pattern matches across lines.
    """
    input_text = ("foo\n" * 500).strip()
    expected = ("bar\n" * 500).strip()
    codeflash_output = replace_til_no_change(input_text, r"foo", "bar") # 19.3μs -> 19.8μs (2.36% slower)

def test_large_scale_pattern_with_digits():
    """
    Replace all digits in a large string.
    """
    input_text = "1234567890" * 100
    codeflash_output = replace_til_no_change(input_text, r"\d", "x") # 65.2μs -> 68.8μs (5.28% slower)


def test_large_scale_pattern_with_whitespace():
    """
    Large input with whitespace, replace all whitespace.
    """
    input_text = ("a b\tc\n" * 200).strip()
    expected = ("a_b_c_" * 200).strip()
    codeflash_output = replace_til_no_change(input_text, r"\s", "_") # 56.7μs -> 54.2μs (4.48% faster)

def test_large_scale_pattern_with_unicode():
    """
    Large input with unicode characters.
    """
    input_text = ("café " * 200).strip()
    expected = ("cafe " * 200).strip()
    codeflash_output = replace_til_no_change(input_text, r"é", "e") # 16.2μs -> 16.4μs (1.13% slower)

# ===========================
# Mutation Testing Guards
# ===========================

def test_mutation_guard_pattern_applied_until_no_change():
    """
    If function only applies pattern once, this test will fail.
    """
    codeflash_output = replace_til_no_change("aaaaa", r"aa", "a") # 5.86μs -> 5.01μs (17.1% faster)

def test_mutation_guard_pattern_applied_at_least_once():
    """
    If function never applies pattern, this test will fail.
    """
    codeflash_output = replace_til_no_change("foo", r"foo", "bar") # 4.74μs -> 4.56μs (3.99% faster)

def test_mutation_guard_pattern_applied_to_all_matches():
    """
    If function only applies to first match, this test will fail.
    """
    codeflash_output = replace_til_no_change("foo foo foo", r"foo", "bar") # 4.36μs -> 4.17μs (4.61% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import re

# imports
import pytest  # used for our unit tests
from guardrails.utils.tokenization_utils import replace_til_no_change

# unit tests

# -------------------------
# Basic Test Cases
# -------------------------

def test_basic_no_match():
    # No pattern matches, so string should remain unchanged
    codeflash_output = replace_til_no_change("hello world", r"x", "y") # 3.66μs -> 3.51μs (4.13% faster)

def test_basic_single_replacement():
    # Single replacement, no further changes needed
    codeflash_output = replace_til_no_change("abc", r"a", "x") # 4.53μs -> 4.22μs (7.37% faster)

def test_basic_multiple_replacements():
    # Multiple matches in the string replaced in one pass
    codeflash_output = replace_til_no_change("aaa", r"a", "b") # 4.23μs -> 4.30μs (1.81% slower)

def test_basic_iterative_replacement():
    # Pattern replacement creates new matches, requiring multiple passes
    # e.g. replace 'ab' with 'ba' in 'abab' => 'baba' => 'abba' => 'baab' (eventually stabilizes)
    # But with this pattern, it should stabilize after one pass
    codeflash_output = replace_til_no_change("abab", r"ab", "ba") # 5.43μs -> 4.63μs (17.4% faster)

def test_basic_chain_replacement():
    # Replace 'ab' with 'ba', then 'ba' with 'ab', should oscillate but function stops when no change
    # 'ab' -> 'ba' -> 'ab' -> ... but since re.sub replaces all in one pass, it will not oscillate
    codeflash_output = replace_til_no_change("ab", r"ab", "ba") # 4.55μs -> 4.02μs (13.3% faster)
    codeflash_output = replace_til_no_change("ba", r"ba", "ab") # 1.61μs -> 1.36μs (17.9% faster)

def test_basic_empty_string():
    # Empty string input should return empty string
    codeflash_output = replace_til_no_change("", r".", "x") # 3.45μs -> 3.88μs (11.0% slower)


def test_basic_empty_replacement():
    # Replace all 'a' with empty string
    codeflash_output = replace_til_no_change("banana", r"a", "") # 5.63μs -> 5.42μs (3.99% faster)

# -------------------------
# Edge Test Cases
# -------------------------

def test_edge_pattern_matches_everything():
    # Replace every character with 'x'
    codeflash_output = replace_til_no_change("abc", r".", "x") # 5.82μs -> 5.54μs (4.94% faster)

def test_edge_pattern_matches_nothing():
    # Pattern that matches nothing
    codeflash_output = replace_til_no_change("abc", r"z+", "x") # 4.57μs -> 4.49μs (1.85% faster)

def test_edge_replacement_creates_new_matches():
    # Replacement creates new matches for the pattern
    # Replace 'aa' with 'a', so 'aaaa' -> 'aaa' -> 'aa' -> 'a'
    codeflash_output = replace_til_no_change("aaaa", r"aa", "a") # 5.07μs -> 4.93μs (2.94% faster)

def test_edge_overlapping_matches():
    # Overlapping matches: replace 'aba' with 'a'
    # 'ababa' -> 'aa' (first 'aba' replaced), then no more matches
    codeflash_output = replace_til_no_change("ababa", r"aba", "a") # 4.90μs -> 4.71μs (4.17% faster)

def test_edge_replacement_is_same_as_pattern():
    # Replacement is same as pattern, should not loop infinitely
    codeflash_output = replace_til_no_change("abcabc", r"abc", "abc") # 3.99μs -> 4.08μs (2.13% slower)

def test_edge_unicode_and_special_characters():
    # Unicode and special characters in pattern and replacement
    codeflash_output = replace_til_no_change("héllo wørld", r"ø", "o") # 4.98μs -> 4.72μs (5.46% faster)
    codeflash_output = replace_til_no_change("a😊b😊c", r"😊", "x") # 2.34μs -> 2.46μs (4.96% slower)

def test_edge_multiline_string():
    # Multiline strings with pattern matching across lines
    s = "foo\nbar\nbaz"
    codeflash_output = replace_til_no_change(s, r"bar", "BAR") # 4.72μs -> 4.13μs (14.2% faster)

def test_edge_pattern_with_group():
    # Pattern with capturing group
    codeflash_output = replace_til_no_change("abc123", r"(\d+)", "NUM") # 6.29μs -> 5.60μs (12.3% faster)


def test_edge_pattern_with_lookahead():
    # Pattern with lookahead, e.g. replace 'a' followed by 'b' with 'x'
    codeflash_output = replace_til_no_change("abacaba", r"a(?=b)", "x") # 6.62μs -> 6.39μs (3.50% faster)

def test_edge_pattern_with_lookbehind():
    # Pattern with lookbehind, e.g. replace 'b' preceded by 'a' with 'x'
    codeflash_output = replace_til_no_change("abacaba", r"(?<=a)b", "x") # 6.60μs -> 6.07μs (8.69% faster)

def test_edge_pattern_with_non_ascii():
    # Non-ascii pattern and replacement
    codeflash_output = replace_til_no_change("naïve café", r"ï", "i") # 5.32μs -> 5.06μs (5.09% faster)
    codeflash_output = replace_til_no_change("naïve café", r"é", "e") # 1.97μs -> 1.90μs (3.42% faster)

def test_edge_pattern_with_escape_sequences():
    # Pattern with escape sequences
    codeflash_output = replace_til_no_change("a\tb\tc", r"\t", ",") # 4.62μs -> 4.41μs (4.69% faster)

def test_edge_pattern_with_numbers():
    # Pattern matches digits
    codeflash_output = replace_til_no_change("a1b2c3", r"\d", "x") # 6.63μs -> 5.67μs (17.0% faster)

def test_edge_pattern_with_word_boundaries():
    # Replace word 'foo' only as a whole word
    codeflash_output = replace_til_no_change("foo food fool", r"\bfoo\b", "bar") # 6.99μs -> 6.17μs (13.4% faster)

def test_edge_pattern_with_start_end_anchors():
    # Replace only at start/end of string
    codeflash_output = replace_til_no_change("abcabc", r"^abc", "x") # 5.12μs -> 5.07μs (1.11% faster)
    codeflash_output = replace_til_no_change("abcabc", r"abc$", "x") # 2.29μs -> 2.28μs (0.526% faster)

def test_edge_replacement_is_empty_and_pattern_matches_entire_string():
    # Remove entire string by matching all
    codeflash_output = replace_til_no_change("abc", r".+", "") # 5.03μs -> 4.61μs (9.05% faster)

def test_edge_pattern_is_dot_star():
    # Replace everything with 'x'
    codeflash_output = replace_til_no_change("abc", r".*", "x") # 6.41μs -> 6.30μs (1.68% faster)

# -------------------------
# Large Scale Test Cases
# -------------------------

def test_large_scale_long_string_simple_replacement():
    # Large string, simple replacement
    s = "a" * 1000
    codeflash_output = replace_til_no_change(s, r"a", "b") # 22.0μs -> 21.6μs (1.63% faster)

def test_large_scale_long_string_iterative_replacement():
    # Large string, iterative replacement
    # Replace 'aa' with 'a', so 'a'*1000 -> 'a'*999 -> ... -> 'a'
    s = "a" * 1000
    codeflash_output = replace_til_no_change(s, r"aa", "a") # 27.7μs -> 25.2μs (9.93% faster)

def test_large_scale_long_string_no_match():
    # Large string, no matches
    s = "a" * 1000
    codeflash_output = replace_til_no_change(s, r"z", "x") # 3.80μs -> 4.32μs (11.8% slower)

def test_large_scale_varied_characters():
    # Large string with varied characters
    s = "".join(["abc" for _ in range(333)])  # 999 characters
    codeflash_output = replace_til_no_change(s, r"b", "x") # 18.3μs -> 18.8μs (2.90% slower)

def test_large_scale_multistep_replacement():
    # Large string, replacement creates new matches
    # Replace 'ab' with 'ba', then 'ba' with 'ab', should stabilize
    s = "ab" * 500
    codeflash_output = replace_til_no_change(s, r"ab", "ba"); result = codeflash_output # 2.76ms -> 2.50ms (10.1% faster)

def test_large_scale_pattern_with_digits():
    # Replace all digits with 'x' in a long string
    s = "".join(str(i % 10) for i in range(1000))
    codeflash_output = replace_til_no_change(s, r"\d", "x") # 68.5μs -> 65.2μs (5.11% faster)

def test_large_scale_pattern_with_word_boundaries():
    # Replace all 'foo' as a word in a long string
    s = "foo " * 1000
    codeflash_output = replace_til_no_change(s, r"\bfoo\b", "bar") # 151μs -> 137μs (9.96% faster)

def test_large_scale_pattern_with_newlines():
    # Replace all newlines with commas
    s = "\n".join(["abc"] * 1000)
    codeflash_output = replace_til_no_change(s, r"\n", ",") # 44.2μs -> 44.7μs (1.15% slower)

def test_large_scale_iterative_removal():
    # Remove all double letters iteratively
    s = "aa" * 500  # 1000 chars
    codeflash_output = replace_til_no_change(s, r"aa", "") # 14.0μs -> 12.3μs (13.6% faster)

def test_large_scale_unicode():
    # Large string with unicode characters
    s = "😊" * 1000
    codeflash_output = replace_til_no_change(s, r"😊", "x") # 21.5μs -> 18.8μs (14.5% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.